package com.wmjsoft.plugins.security.base

import com.wmjsoft.plugins.nutzplugin.dao.MyDao
import com.wmjsoft.plugins.security.user.CurrentUser
import com.wmjsoft.plugins.security.user.UserDetails
import java.lang.RuntimeException
import java.util.*


abstract class MyBaseService<T : Any> {

    abstract fun getClazzT(): Class<T>

    /**
     * 获取上下文中的用户
     */
    fun getCurrentUser(): UserDetails {
        return CurrentUser.getCurrentUser()
    }


    /**
     * 保存
     */
    open fun save(t: T): T {
        InitCreateUpdateUser.initCreateUser(t)
        val save = MyDao.inserter(getClazzT()).insert(t)
        isFalse(null != save, "保存失败")
        return save
    }






    /**
     * 保存列表
     */
    open fun saveAll(ts: List<T>): ArrayList<T>? {
        var tList = ArrayList<T>()
        for (i in ts) {
            InitCreateUpdateUser.initCreateUser(i)
            tList.add(i)
        }
        val insert = MyDao.inserter(getClazzT()).insert(tList)
        return insert
    }

    /**
     * 根据id修改
     */
    open fun updateById(t: T): Int {
        val id = ClassUtils.getProperty(t, "id") ?: throw RuntimeException("id为空")
        InitCreateUpdateUser.initLastUpdateUser(t)
        val result = MyDao.updater(getClazzT()).setTtoFiled(t).where().eq("id",id).update()
        isNull(result, "修改失败")
        return result
    }

    /**
     * 根据id删除
     */
    open fun deleteById(id: Long) {
        isFalse(id != null,"请选择删除的数据")
        val result = MyDao.deleter(getClazzT()).where().eq("id", id).delete()
        isFalse(result > 0, "删除失败")
    }

    /**
     * 根据id逻辑删除
     */
    open fun lDeleteById(id: Long) {
        isFalse(ClassUtils.hasColumn(getClazzT(), "deleteStatus"), "该类不支持逻辑删除")
        isFalse(id != null,"请选择删除的数据")
        val result = MyDao.updater(getClazzT()).set("deleteStatus", 1).where().eq("id", id).update()
        isFalse(result > 0, "删除失败")
    }

    /**
     * 根据id批量删除，id为String，根据','拼接
     */
    open fun bachDeleteByIds(ids: List<Long>) {
        isEmpty(ids,"请选择要删除的内容")
        for(i in ids){
            if(i != null){
                break
            }
        }
        val result = MyDao.deleter(getClazzT()).where().`in`("id", ids).delete()
        isFalse(result > 0,"删除失败")
    }

    /**
     * 根据id批量逻辑删除，id为String，根据','拼接
     */
    open fun bachLDeleteByIds(ids: List<Long>) {
        isEmpty(ids,"请选择要删除的内容")
        for(i in ids){
            if(i != null){
                break
            }
        }
        isFalse(ClassUtils.hasColumn(getClazzT(), "deleteStatus"),"该类不支持逻辑删除")

        val result = MyDao.updater(getClazzT()).set("deleteStatus", 1).where().`in`("id", ids).update()
        isFalse(result > 0,"删除失败")
    }

    /**
     * 根据id获取单个详细信息，默认查询所有字段，返回实体类
     */
    open fun getInfoById(id: Long): T? {
        val result = MyDao.find(this.getClazzT()).where().eq("deleteStatus",0).eq("id", id).one(getClazzT())
        return result
    }

    /**
     * 根据id获取单个详细信息，默认查询所有字段，返回DTO
     */
    open fun <DTO> getInfoDtoById(id: Long, clazz: Class<DTO>): DTO? {
        return MyDao.find(this.getClazzT()).where().eq("deleteStatus",0).eq("id", id).one(clazz)
    }




}